home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / xcoral / xcoral.lha / xcoral-1.72 / gen.tab.c < prev    next >
C/C++ Source or Header  |  1993-02-26  |  27KB  |  1,007 lines
  1. extern char *malloc(), *realloc();
  2.  
  3. # line 2 "gen.y"
  4.  
  5. #include "global_parse.h"
  6. #include "result_types.h"
  7. #include "file_dict.h"
  8. #include "proc_dict.h"
  9. #include "class_dict.h"
  10. #include "browser_pars.h"
  11. #include "browser_util.h"
  12. #include <stdio.h>
  13.  
  14.  
  15. /*------------------------------------------------------------------------------
  16. */
  17. char yy_class_name[256];
  18.  
  19.  
  20. static ScopeType yy_scope;
  21.  
  22. #define S_PRECEDENCE       10
  23. #define P_PRECEDENCE       10
  24. #define A_PRECEDENCE       20
  25. #define MAX_PRECEDENCE     30
  26.  
  27. #define parentheses(ref_prec, inter, result) \
  28.           if (inter.precedence < ref_prec)   \
  29.             strcat(result.text, "(");        \
  30.           strcat(result.text, inter.text);   \
  31.           if (inter.precedence < ref_prec)   \
  32.             strcat(result.text, ")");        \
  33.           result.precedence = ref_prec;
  34.  
  35.  
  36. #define YYDEBUG 1
  37.  
  38.  
  39. # define ARRAY_TOK 257
  40. # define UNSIGNED_TOK 258
  41. # define SIGNED_TOK 259
  42. # define CHAR_TOK 260
  43. # define SHORT_TOK 261
  44. # define INT_TOK 262
  45. # define LONG_TOK 263
  46. # define STRUCT_TOK 264
  47. # define UNION_TOK 265
  48. # define CLASS_TOK 266
  49. # define CONST_TOK 267
  50. # define IDENT_TOK 268
  51. # define CPLUS_TOK 269
  52. # define C_TOK 270
  53. # define DECL_TOK 271
  54. # define SYNC_TOK 272
  55. # define PUBLIC_TOK 273
  56. # define PROTECTED_TOK 274
  57. # define PRIVATE_TOK 275
  58. # define LEX_ERROR_TOK 276
  59. #define yyclearin yychar = -1
  60. #define yyerrok yyerrflag = 0
  61. extern int yychar;
  62. extern int yyerrflag;
  63. #ifndef YYMAXDEPTH
  64. #define YYMAXDEPTH 150
  65. #endif
  66. #ifndef YYSTYPE
  67. #define YYSTYPE int
  68. #endif
  69. YYSTYPE yylval, yyval;
  70. # define YYERRCODE 256
  71.  
  72. # line 315 "gen.y"
  73.  
  74.  
  75. int yyerror(error_msg)
  76.     char* error_msg;
  77. {
  78.     if ( OpVerbose () == True ) {
  79.       fprintf(stderr, "warning >>>>>>  Internal Parser Error at line %d\n", line_count);
  80.       fprintf(stderr, "warning    >>  %s\n", error_msg);
  81.     }
  82. }
  83.  
  84.  
  85. int browser_yyparse(file_name)
  86.     char* file_name;
  87. {
  88.   FILE* file;
  89.   int   result;
  90.  
  91.   result = 1;
  92.   *yy_class_name = '\0';
  93.   file = fopen(file_name, "r");
  94.   if (file != Null) {
  95.     flex_init(file);
  96.     result = yyparse();
  97.     fclose(file);
  98.   }
  99.   else
  100.     fprintf(stderr, "\n>>>>>>  Unable to open file %s\n", file_name);
  101.   return(result);
  102. }int yyexca[] ={
  103. -1, 1,
  104.     0, -1,
  105.     -2, 0,
  106.     };
  107. # define YYNPROD 64
  108. # define YYLAST 250
  109. int yyact[]={
  110.  
  111.     76,     9,     6,     7,    73,     4,    72,    71,    53,     8,
  112.     60,    33,    61,    60,    59,    61,    48,    59,    60,    60,
  113.     61,    61,    59,    59,    19,    32,    31,    78,    92,    80,
  114.     34,    29,    56,    77,    10,    39,    40,    38,    41,    42,
  115.     43,    44,    45,    46,    37,    47,    39,    40,    38,    41,
  116.     42,    43,    44,    45,    46,    35,    47,    67,    68,    69,
  117.     70,    63,    64,    65,    66,    97,    20,    89,    55,    88,
  118.     55,    54,    55,    95,    55,    51,    50,    17,    18,    36,
  119.     11,    74,    75,     5,    12,    49,     3,     2,     1,     0,
  120.     81,     0,    82,    84,    86,    87,    30,     0,     0,     0,
  121.      0,     0,     0,     0,     0,     0,     0,     0,    52,     0,
  122.      0,    79,     0,     0,     0,     0,    90,    62,    91,    49,
  123.      0,     0,    93,    94,     0,     0,    96,     0,     0,     0,
  124.      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
  125.      0,     0,     0,     0,    25,    26,    24,    27,    21,    22,
  126.     23,    28,    25,    26,    24,    27,    21,    22,    23,    28,
  127.     25,    26,    24,    27,    21,    22,    23,    28,    25,    26,
  128.     24,    27,    21,    22,    23,    28,    16,     0,     0,    16,
  129.      0,    13,    14,    15,    13,    14,    15,     0,     0,     0,
  130.      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
  131.      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
  132.      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
  133.      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
  134.      0,     0,     0,     0,     0,     0,     0,     0,     0,    85,
  135.     58,     0,    83,    58,    80,     0,     0,    57,    58,    58 };
  136. int yypact[]={
  137.  
  138.  -1000,  -267, -1000, -1000, -1000,   -89,    37, -1000, -1000, -1000,
  139.   -101,   -92, -1000,  -242,  -243,  -257, -1000,  -223,  -109, -1000,
  140.  -1000, -1000, -1000, -1000,    36,    35, -1000, -1000, -1000,  -117,
  141.  -1000, -1000, -1000, -1000,    30, -1000,   -20,  -212, -1000,  -199,
  142.   -203, -1000, -1000, -1000,  -261,  -262,  -264, -1000, -1000, -1000,
  143.   -223,  -223,  -125, -1000,  -240,  -223,  -228,   -19, -1000,   -25,
  144.    -28,   -19,   -19, -1000, -1000, -1000, -1000, -1000, -1000, -1000,
  145.  -1000, -1000, -1000, -1000,    28,    26, -1000, -1000, -1000, -1000,
  146.  -1000,  -228,  -228,   -19,  -228,   -19,   -13,  -228,  -240,  -240,
  147.   -228,  -228,    33, -1000, -1000,  -223,    24, -1000 };
  148. int yypgo[]={
  149.  
  150.      0,    88,    87,    86,    83,    78,    80,    84,    66,    30,
  151.     33,    55,    79,    32 };
  152. int yyr1[]={
  153.  
  154.      0,     1,     1,     1,     1,     2,     2,     2,     2,     4,
  155.      6,     6,     7,     7,     7,     7,     5,     5,     8,     8,
  156.      8,     8,     8,     8,     8,     8,     3,     3,     3,    10,
  157.     10,     9,     9,     9,    11,    11,    11,    12,    12,    12,
  158.     12,    12,    12,    12,    12,    12,    12,    12,    12,    12,
  159.     12,    12,    12,    12,    12,    13,    13,    13,    13,    13,
  160.     13,    13,    13,    13 };
  161. int yyr2[]={
  162.  
  163.      0,     1,     4,     4,     4,     8,     6,    10,     8,     3,
  164.      2,     4,     5,     5,     5,     3,     2,     4,     3,     3,
  165.      3,    11,    11,     2,     2,     3,    11,     3,     3,     1,
  166.      3,     1,     3,     7,     5,     7,     7,     3,     5,     5,
  167.      3,     5,     5,     3,     5,     5,     3,     3,     3,     5,
  168.      5,     5,     5,     5,     3,     1,     3,     5,     7,     5,
  169.      7,     5,    13,     7 };
  170. int yychk[]={
  171.  
  172.  -1000,    -1,    -2,    -3,   272,    -4,   269,   270,   276,   268,
  173.    123,    -6,    -7,   273,   274,   275,   268,    40,    -5,   125,
  174.     -8,   273,   274,   275,   271,   269,   270,   272,   276,   123,
  175.     -7,   268,   268,   268,    -9,   -11,   -12,   267,   260,   258,
  176.    259,   261,   262,   263,   264,   265,   266,   268,   125,    -8,
  177.     40,    40,    -5,   125,    41,    44,   -13,   267,   268,    42,
  178.     38,    40,   -12,   260,   261,   262,   263,   260,   261,   262,
  179.    263,   268,   268,   268,    -9,    -9,   125,   -10,   267,   -11,
  180.    257,   -13,   -13,   267,   -13,   267,   -13,   -13,    41,    41,
  181.    -13,   -13,    41,   -10,   -10,    40,    -9,    41 };
  182. int yydef[]={
  183.  
  184.      1,    -2,     2,     3,     4,     0,     0,    27,    28,     9,
  185.      0,     0,    10,     0,     0,     0,    15,    31,     0,     6,
  186.     16,    18,    19,    20,     0,     0,    23,    24,    25,     0,
  187.     11,    12,    13,    14,     0,    32,    55,     0,    37,    46,
  188.     47,    40,    43,    48,     0,     0,     0,    54,     5,    17,
  189.     31,    31,     0,     8,    29,     0,    34,    55,    56,    55,
  190.     55,    55,    55,    38,    41,    44,    49,    39,    42,    45,
  191.     50,    51,    52,    53,     0,     0,     7,    26,    30,    33,
  192.     61,    36,    57,    55,    59,    55,     0,    35,    29,    29,
  193.     58,    60,    63,    21,    22,    31,     0,    62 };
  194. typedef struct { char *t_name; int t_val; } yytoktype;
  195. #ifndef YYDEBUG
  196. #    define YYDEBUG    0    /* don't allow debugging */
  197. #endif
  198.  
  199. #if YYDEBUG
  200.  
  201. yytoktype yytoks[] =
  202. {
  203.     "*",    42,
  204.     "&",    38,
  205.     "ARRAY_TOK",    257,
  206.     "UNSIGNED_TOK",    258,
  207.     "SIGNED_TOK",    259,
  208.     "CHAR_TOK",    260,
  209.     "SHORT_TOK",    261,
  210.     "INT_TOK",    262,
  211.     "LONG_TOK",    263,
  212.     "STRUCT_TOK",    264,
  213.     "UNION_TOK",    265,
  214.     "CLASS_TOK",    266,
  215.     "CONST_TOK",    267,
  216.     "IDENT_TOK",    268,
  217.     "CPLUS_TOK",    269,
  218.     "C_TOK",    270,
  219.     "DECL_TOK",    271,
  220.     "SYNC_TOK",    272,
  221.     "PUBLIC_TOK",    273,
  222.     "PROTECTED_TOK",    274,
  223.     "PRIVATE_TOK",    275,
  224.     "LEX_ERROR_TOK",    276,
  225.     "-unknown-",    -1    /* ends search */
  226. };
  227.  
  228. char * yyreds[] =
  229. {
  230.     "-no such reduction-",
  231.     "file : /* empty */",
  232.     "file : file class_decl",
  233.     "file : file procedure_impl",
  234.     "file : file SYNC_TOK",
  235.     "class_decl : class_name '{' member_list '}'",
  236.     "class_decl : class_name '{' '}'",
  237.     "class_decl : class_name parent_list '{' member_list '}'",
  238.     "class_decl : class_name parent_list '{' '}'",
  239.     "class_name : IDENT_TOK",
  240.     "parent_list : parent",
  241.     "parent_list : parent_list parent",
  242.     "parent : PUBLIC_TOK IDENT_TOK",
  243.     "parent : PROTECTED_TOK IDENT_TOK",
  244.     "parent : PRIVATE_TOK IDENT_TOK",
  245.     "parent : IDENT_TOK",
  246.     "member_list : member_decl",
  247.     "member_list : member_list member_decl",
  248.     "member_decl : PUBLIC_TOK",
  249.     "member_decl : PROTECTED_TOK",
  250.     "member_decl : PRIVATE_TOK",
  251.     "member_decl : DECL_TOK '(' arguments_list ')' trail_decl",
  252.     "member_decl : CPLUS_TOK '(' arguments_list ')' trail_decl",
  253.     "member_decl : C_TOK",
  254.     "member_decl : SYNC_TOK",
  255.     "member_decl : LEX_ERROR_TOK",
  256.     "procedure_impl : CPLUS_TOK '(' arguments_list ')' trail_decl",
  257.     "procedure_impl : C_TOK",
  258.     "procedure_impl : LEX_ERROR_TOK",
  259.     "trail_decl : /* empty */",
  260.     "trail_decl : CONST_TOK",
  261.     "arguments_list : /* empty */",
  262.     "arguments_list : argument",
  263.     "arguments_list : arguments_list ',' argument",
  264.     "argument : type declarator",
  265.     "argument : CONST_TOK type declarator",
  266.     "argument : type CONST_TOK declarator",
  267.     "type : CHAR_TOK",
  268.     "type : UNSIGNED_TOK CHAR_TOK",
  269.     "type : SIGNED_TOK CHAR_TOK",
  270.     "type : SHORT_TOK",
  271.     "type : UNSIGNED_TOK SHORT_TOK",
  272.     "type : SIGNED_TOK SHORT_TOK",
  273.     "type : INT_TOK",
  274.     "type : UNSIGNED_TOK INT_TOK",
  275.     "type : SIGNED_TOK INT_TOK",
  276.     "type : UNSIGNED_TOK",
  277.     "type : SIGNED_TOK",
  278.     "type : LONG_TOK",
  279.     "type : UNSIGNED_TOK LONG_TOK",
  280.     "type : SIGNED_TOK LONG_TOK",
  281.     "type : STRUCT_TOK IDENT_TOK",
  282.     "type : UNION_TOK IDENT_TOK",
  283.     "type : CLASS_TOK IDENT_TOK",
  284.     "type : IDENT_TOK",
  285.     "declarator : /* empty */",
  286.     "declarator : IDENT_TOK",
  287.     "declarator : '*' declarator",
  288.     "declarator : '*' CONST_TOK declarator",
  289.     "declarator : '&' declarator",
  290.     "declarator : '&' CONST_TOK declarator",
  291.     "declarator : declarator ARRAY_TOK",
  292.     "declarator : '(' declarator ')' '(' arguments_list ')'",
  293.     "declarator : '(' declarator ')'",
  294. };
  295. #endif /* YYDEBUG */
  296. #line 1 "/usr/lib/yaccpar"
  297. /*    @(#)yaccpar 1.10 89/04/04 SMI; from S5R3 1.10    */
  298.  
  299. /*
  300. ** Skeleton parser driver for yacc output
  301. */
  302.  
  303. /*
  304. ** yacc user known macros and defines
  305. */
  306. #define YYERROR        goto yyerrlab
  307. #define YYACCEPT    { free(yys); free(yyv); return(0); }
  308. #define YYABORT        { free(yys); free(yyv); return(1); }
  309. #define YYBACKUP( newtoken, newvalue )\
  310. {\
  311.     if ( yychar >= 0 || ( yyr2[ yytmp ] >> 1 ) != 1 )\
  312.     {\
  313.         yyerror( "syntax error - cannot backup" );\
  314.         goto yyerrlab;\
  315.     }\
  316.     yychar = newtoken;\
  317.     yystate = *yyps;\
  318.     yylval = newvalue;\
  319.     goto yynewstate;\
  320. }
  321. #define YYRECOVERING()    (!!yyerrflag)
  322. #ifndef YYDEBUG
  323. #    define YYDEBUG    1    /* make debugging available */
  324. #endif
  325.  
  326. /*
  327. ** user known globals
  328. */
  329. int yydebug;            /* set to 1 to get debugging */
  330.  
  331. /*
  332. ** driver internal defines
  333. */
  334. #define YYFLAG        (-1000)
  335.  
  336. /*
  337. ** static variables used by the parser
  338. */
  339. static YYSTYPE *yyv;            /* value stack */
  340. static int *yys;            /* state stack */
  341.  
  342. static YYSTYPE *yypv;            /* top of value stack */
  343. static int *yyps;            /* top of state stack */
  344.  
  345. static int yystate;            /* current state */
  346. static int yytmp;            /* extra var (lasts between blocks) */
  347.  
  348. int yynerrs;            /* number of errors */
  349.  
  350. int yyerrflag;            /* error recovery flag */
  351. int yychar;            /* current input token number */
  352.  
  353.  
  354. /*
  355. ** yyparse - return 0 if worked, 1 if syntax error not recovered from
  356. */
  357. int
  358. yyparse()
  359. {
  360.     register YYSTYPE *yypvt;    /* top of value stack for $vars */
  361.     unsigned yymaxdepth = YYMAXDEPTH;
  362.  
  363.     /*
  364.     ** Initialize externals - yyparse may be called more than once
  365.     */
  366.     yyv = (YYSTYPE*)malloc(yymaxdepth*sizeof(YYSTYPE));
  367.     yys = (int*)malloc(yymaxdepth*sizeof(int));
  368.     if (!yyv || !yys)
  369.     {
  370.         yyerror( "out of memory" );
  371.         return(1);
  372.     }
  373.     yypv = &yyv[-1];
  374.     yyps = &yys[-1];
  375.     yystate = 0;
  376.     yytmp = 0;
  377.     yynerrs = 0;
  378.     yyerrflag = 0;
  379.     yychar = -1;
  380.  
  381.     goto yystack;
  382.     {
  383.         register YYSTYPE *yy_pv;    /* top of value stack */
  384.         register int *yy_ps;        /* top of state stack */
  385.         register int yy_state;        /* current state */
  386.         register int  yy_n;        /* internal state number info */
  387.  
  388.         /*
  389.         ** get globals into registers.
  390.         ** branch to here only if YYBACKUP was called.
  391.         */
  392.     yynewstate:
  393.         yy_pv = yypv;
  394.         yy_ps = yyps;
  395.         yy_state = yystate;
  396.         goto yy_newstate;
  397.  
  398.         /*
  399.         ** get globals into registers.
  400.         ** either we just started, or we just finished a reduction
  401.         */
  402.     yystack:
  403.         yy_pv = yypv;
  404.         yy_ps = yyps;
  405.         yy_state = yystate;
  406.  
  407.         /*
  408.         ** top of for (;;) loop while no reductions done
  409.         */
  410.     yy_stack:
  411.         /*
  412.         ** put a state and value onto the stacks
  413.         */
  414. #if YYDEBUG
  415.         /*
  416.         ** if debugging, look up token value in list of value vs.
  417.         ** name pairs.  0 and negative (-1) are special values.
  418.         ** Note: linear search is used since time is not a real
  419.         ** consideration while debugging.
  420.         */
  421.         if ( yydebug )
  422.         {
  423.             register int yy_i;
  424.  
  425.             (void)printf( "State %d, token ", yy_state );
  426.             if ( yychar == 0 )
  427.                 (void)printf( "end-of-file\n" );
  428.             else if ( yychar < 0 )
  429.                 (void)printf( "-none-\n" );
  430.             else
  431.             {
  432.                 for ( yy_i = 0; yytoks[yy_i].t_val >= 0;
  433.                     yy_i++ )
  434.                 {
  435.                     if ( yytoks[yy_i].t_val == yychar )
  436.                         break;
  437.                 }
  438.                 (void)printf( "%s\n", yytoks[yy_i].t_name );
  439.             }
  440.         }
  441. #endif /* YYDEBUG */
  442.         if ( ++yy_ps >= &yys[ yymaxdepth ] )    /* room on stack? */
  443.         {
  444.             /*
  445.             ** reallocate and recover.  Note that pointers
  446.             ** have to be reset, or bad things will happen
  447.             */
  448.             int yyps_index = (yy_ps - yys);
  449.             int yypv_index = (yy_pv - yyv);
  450.             int yypvt_index = (yypvt - yyv);
  451.             yymaxdepth += YYMAXDEPTH;
  452.             yyv = (YYSTYPE*)realloc((char*)yyv,
  453.                 yymaxdepth * sizeof(YYSTYPE));
  454.             yys = (int*)realloc((char*)yys,
  455.                 yymaxdepth * sizeof(int));
  456.             if (!yyv || !yys)
  457.             {
  458.                 yyerror( "yacc stack overflow" );
  459.                 return(1);
  460.             }
  461.             yy_ps = yys + yyps_index;
  462.             yy_pv = yyv + yypv_index;
  463.             yypvt = yyv + yypvt_index;
  464.         }
  465.         *yy_ps = yy_state;
  466.         *++yy_pv = yyval;
  467.  
  468.         /*
  469.         ** we have a new state - find out what to do
  470.         */
  471.     yy_newstate:
  472.         if ( ( yy_n = yypact[ yy_state ] ) <= YYFLAG )
  473.             goto yydefault;        /* simple state */
  474. #if YYDEBUG
  475.         /*
  476.         ** if debugging, need to mark whether new token grabbed
  477.         */
  478.         yytmp = yychar < 0;
  479. #endif
  480.         if ( ( yychar < 0 ) && ( ( yychar = yylex() ) < 0 ) )
  481.             yychar = 0;        /* reached EOF */
  482. #if YYDEBUG
  483.         if ( yydebug && yytmp )
  484.         {
  485.             register int yy_i;
  486.  
  487.             (void)printf( "Received token " );
  488.             if ( yychar == 0 )
  489.                 (void)printf( "end-of-file\n" );
  490.             else if ( yychar < 0 )
  491.                 (void)printf( "-none-\n" );
  492.             else
  493.             {
  494.                 for ( yy_i = 0; yytoks[yy_i].t_val >= 0;
  495.                     yy_i++ )
  496.                 {
  497.                     if ( yytoks[yy_i].t_val == yychar )
  498.                         break;
  499.                 }
  500.                 (void)printf( "%s\n", yytoks[yy_i].t_name );
  501.             }
  502.         }
  503. #endif /* YYDEBUG */
  504.         if ( ( ( yy_n += yychar ) < 0 ) || ( yy_n >= YYLAST ) )
  505.             goto yydefault;
  506.         if ( yychk[ yy_n = yyact[ yy_n ] ] == yychar )    /*valid shift*/
  507.         {
  508.             yychar = -1;
  509.             yyval = yylval;
  510.             yy_state = yy_n;
  511.             if ( yyerrflag > 0 )
  512.                 yyerrflag--;
  513.             goto yy_stack;
  514.         }
  515.  
  516.     yydefault:
  517.         if ( ( yy_n = yydef[ yy_state ] ) == -2 )
  518.         {
  519. #if YYDEBUG
  520.             yytmp = yychar < 0;
  521. #endif
  522.             if ( ( yychar < 0 ) && ( ( yychar = yylex() ) < 0 ) )
  523.                 yychar = 0;        /* reached EOF */
  524. #if YYDEBUG
  525.             if ( yydebug && yytmp )
  526.             {
  527.                 register int yy_i;
  528.  
  529.                 (void)printf( "Received token " );
  530.                 if ( yychar == 0 )
  531.                     (void)printf( "end-of-file\n" );
  532.                 else if ( yychar < 0 )
  533.                     (void)printf( "-none-\n" );
  534.                 else
  535.                 {
  536.                     for ( yy_i = 0;
  537.                         yytoks[yy_i].t_val >= 0;
  538.                         yy_i++ )
  539.                     {
  540.                         if ( yytoks[yy_i].t_val
  541.                             == yychar )
  542.                         {
  543.                             break;
  544.                         }
  545.                     }
  546.                     (void)printf( "%s\n", yytoks[yy_i].t_name );
  547.                 }
  548.             }
  549. #endif /* YYDEBUG */
  550.             /*
  551.             ** look through exception table
  552.             */
  553.             {
  554.                 register int *yyxi = yyexca;
  555.  
  556.                 while ( ( *yyxi != -1 ) ||
  557.                     ( yyxi[1] != yy_state ) )
  558.                 {
  559.                     yyxi += 2;
  560.                 }
  561.                 while ( ( *(yyxi += 2) >= 0 ) &&
  562.                     ( *yyxi != yychar ) )
  563.                     ;
  564.                 if ( ( yy_n = yyxi[1] ) < 0 )
  565.                     YYACCEPT;
  566.             }
  567.         }
  568.  
  569.         /*
  570.         ** check for syntax error
  571.         */
  572.         if ( yy_n == 0 )    /* have an error */
  573.         {
  574.             /* no worry about speed here! */
  575.             switch ( yyerrflag )
  576.             {
  577.             case 0:        /* new error */
  578.                 yyerror( "syntax error" );
  579.                 goto skip_init;
  580.             yyerrlab:
  581.                 /*
  582.                 ** get globals into registers.
  583.                 ** we have a user generated syntax type error
  584.                 */
  585.                 yy_pv = yypv;
  586.                 yy_ps = yyps;
  587.                 yy_state = yystate;
  588.                 yynerrs++;
  589.             skip_init:
  590.             case 1:
  591.             case 2:        /* incompletely recovered error */
  592.                     /* try again... */
  593.                 yyerrflag = 3;
  594.                 /*
  595.                 ** find state where "error" is a legal
  596.                 ** shift action
  597.                 */
  598.                 while ( yy_ps >= yys )
  599.                 {
  600.                     yy_n = yypact[ *yy_ps ] + YYERRCODE;
  601.                     if ( yy_n >= 0 && yy_n < YYLAST &&
  602.                         yychk[yyact[yy_n]] == YYERRCODE)                    {
  603.                         /*
  604.                         ** simulate shift of "error"
  605.                         */
  606.                         yy_state = yyact[ yy_n ];
  607.                         goto yy_stack;
  608.                     }
  609.                     /*
  610.                     ** current state has no shift on
  611.                     ** "error", pop stack
  612.                     */
  613. #if YYDEBUG
  614. #    define _POP_ "Error recovery pops state %d, uncovers state %d\n"
  615.                     if ( yydebug )
  616.                         (void)printf( _POP_, *yy_ps,
  617.                             yy_ps[-1] );
  618. #    undef _POP_
  619. #endif
  620.                     yy_ps--;
  621.                     yy_pv--;
  622.                 }
  623.                 /*
  624.                 ** there is no state on stack with "error" as
  625.                 ** a valid shift.  give up.
  626.                 */
  627.                 YYABORT;
  628.             case 3:        /* no shift yet; eat a token */
  629. #if YYDEBUG
  630.                 /*
  631.                 ** if debugging, look up token in list of
  632.                 ** pairs.  0 and negative shouldn't occur,
  633.                 ** but since timing doesn't matter when
  634.                 ** debugging, it doesn't hurt to leave the
  635.                 ** tests here.
  636.                 */
  637.                 if ( yydebug )
  638.                 {
  639.                     register int yy_i;
  640.  
  641.                     (void)printf( "Error recovery discards " );
  642.                     if ( yychar == 0 )
  643.                         (void)printf( "token end-of-file\n" );
  644.                     else if ( yychar < 0 )
  645.                         (void)printf( "token -none-\n" );
  646.                     else
  647.                     {
  648.                         for ( yy_i = 0;
  649.                             yytoks[yy_i].t_val >= 0;
  650.                             yy_i++ )
  651.                         {
  652.                             if ( yytoks[yy_i].t_val
  653.                                 == yychar )
  654.                             {
  655.                                 break;
  656.                             }
  657.                         }
  658.                         (void)printf( "token %s\n",
  659.                             yytoks[yy_i].t_name );
  660.                     }
  661.                 }
  662. #endif /* YYDEBUG */
  663.                 if ( yychar == 0 )    /* reached EOF. quit */
  664.                     YYABORT;
  665.                 yychar = -1;
  666.                 goto yy_newstate;
  667.             }
  668.         }/* end if ( yy_n == 0 ) */
  669.         /*
  670.         ** reduction by production yy_n
  671.         ** put stack tops, etc. so things right after switch
  672.         */
  673. #if YYDEBUG
  674.         /*
  675.         ** if debugging, print the string that is the user's
  676.         ** specification of the reduction which is just about
  677.         ** to be done.
  678.         */
  679.         if ( yydebug )
  680.             (void)printf( "Reduce by (%d) \"%s\"\n",
  681.                 yy_n, yyreds[ yy_n ] );
  682. #endif
  683.         yytmp = yy_n;            /* value to switch over */
  684.         yypvt = yy_pv;            /* $vars top of value stack */
  685.         /*
  686.         ** Look in goto table for next state
  687.         ** Sorry about using yy_state here as temporary
  688.         ** register variable, but why not, if it works...
  689.         ** If yyr2[ yy_n ] doesn't have the low order bit
  690.         ** set, then there is no action to be done for
  691.         ** this reduction.  So, no saving & unsaving of
  692.         ** registers done.  The only difference between the
  693.         ** code just after the if and the body of the if is
  694.         ** the goto yy_stack in the body.  This way the test
  695.         ** can be made before the choice of what to do is needed.
  696.         */
  697.         {
  698.             /* length of production doubled with extra bit */
  699.             register int yy_len = yyr2[ yy_n ];
  700.  
  701.             if ( !( yy_len & 01 ) )
  702.             {
  703.                 yy_len >>= 1;
  704.                 yyval = ( yy_pv -= yy_len )[1];    /* $$ = $1 */
  705.                 yy_state = yypgo[ yy_n = yyr1[ yy_n ] ] +
  706.                     *( yy_ps -= yy_len ) + 1;
  707.                 if ( yy_state >= YYLAST ||
  708.                     yychk[ yy_state =
  709.                     yyact[ yy_state ] ] != -yy_n )
  710.                 {
  711.                     yy_state = yyact[ yypgo[ yy_n ] ];
  712.                 }
  713.                 goto yy_stack;
  714.             }
  715.             yy_len >>= 1;
  716.             yyval = ( yy_pv -= yy_len )[1];    /* $$ = $1 */
  717.             yy_state = yypgo[ yy_n = yyr1[ yy_n ] ] +
  718.                 *( yy_ps -= yy_len ) + 1;
  719.             if ( yy_state >= YYLAST ||
  720.                 yychk[ yy_state = yyact[ yy_state ] ] != -yy_n )
  721.             {
  722.                 yy_state = yyact[ yypgo[ yy_n ] ];
  723.             }
  724.         }
  725.                     /* save until reenter driver code */
  726.         yystate = yy_state;
  727.         yyps = yy_ps;
  728.         yypv = yy_pv;
  729.     }
  730.     /*
  731.     ** code supplied by user is placed in this switch
  732.     */
  733.     switch( yytmp )
  734.     {
  735.         
  736. case 1:
  737. # line 56 "gen.y"
  738. { yydebug = 0; } break;
  739. case 9:
  740. # line 76 "gen.y"
  741. {
  742.       strcpy(yy_class_name, yypvt[-0].text);
  743.       if (add_class_decl(yypvt[-0].text, yypvt[-0].position) == BERROR)
  744.         YYABORT;
  745.       yy_scope = PRIVATE_TOK;
  746.     } break;
  747. case 12:
  748. # line 96 "gen.y"
  749. {
  750.       if (add_parent(yy_class_name, yypvt[-0].text, PUBLIC_SCOPE) == BERROR)
  751.         YYABORT;
  752.     } break;
  753. case 13:
  754. # line 100 "gen.y"
  755. {
  756.       if (add_parent(yy_class_name, yypvt[-0].text, PROTECTED_SCOPE) == BERROR)
  757.         YYABORT;
  758.     } break;
  759. case 14:
  760. # line 104 "gen.y"
  761. {
  762.       if (add_parent(yy_class_name, yypvt[-0].text, PRIVATE_SCOPE) == BERROR)
  763.         YYABORT;
  764.     } break;
  765. case 15:
  766. # line 108 "gen.y"
  767. {
  768.       if (add_parent(yy_class_name, yypvt[-0].text, PRIVATE_SCOPE) == BERROR)
  769.         YYABORT;
  770.     } break;
  771. case 18:
  772. # line 126 "gen.y"
  773. {
  774.       yy_scope = PUBLIC_SCOPE;
  775.     } break;
  776. case 19:
  777. # line 129 "gen.y"
  778. {
  779.       yy_scope = PROTECTED_SCOPE;
  780.     } break;
  781. case 20:
  782. # line 132 "gen.y"
  783. {
  784.       yy_scope = PRIVATE_SCOPE;
  785.     } break;
  786. case 21:
  787. # line 135 "gen.y"
  788. {
  789.       strcpy(yyval.text, yypvt[-4].text);
  790.       strcat(yyval.text, "(");
  791.       strcat(yyval.text, yypvt[-2].text);
  792.       strcat(yyval.text, ")");
  793.       strcat(yyval.text, yypvt[-0].text);
  794.       if (add_method_decl(yy_class_name, yyval.text,
  795.                           yy_scope, yypvt[-4].is_virtual, yypvt[-4].position) == BERROR)
  796.         YYABORT;
  797.     } break;
  798. case 22:
  799. # line 145 "gen.y"
  800. {
  801.       strcpy(yyval.text, yypvt[-4].text);
  802.       strcat(yyval.text, "(");
  803.       strcat(yyval.text, yypvt[-2].text);
  804.       strcat(yyval.text, ")");
  805.       strcat(yyval.text, yypvt[-0].text);
  806.       if (add_method_decl(yy_class_name, yyval.text,
  807.                           yy_scope, yypvt[-4].is_virtual, yypvt[-4].position) == BERROR)
  808.         YYABORT;
  809.       if (add_method_impl(yy_class_name, yyval.text, yypvt[-4].position) == BERROR)
  810.         YYABORT;
  811.     } break;
  812. case 25:
  813. # line 159 "gen.y"
  814. {
  815.       fprintf(stderr, ">>>>>>  Arguments buffer overflow at line %d\n", yypvt[-0].position);
  816.       YYABORT;
  817.     } break;
  818. case 26:
  819. # line 169 "gen.y"
  820. {
  821.       strcpy(yyval.text, yypvt[-4].text);
  822.       strcat(yyval.text, "(");
  823.       strcat(yyval.text, yypvt[-2].text);
  824.       strcat(yyval.text, ")");
  825.       strcat(yyval.text, yypvt[-0].text);
  826.       if (yy_class_name[0] == '\0') {
  827.         if (add_proc_impl(yyval.text, CPLUS_PROC, yypvt[-4].position) == BERROR)
  828.           YYABORT;
  829.       }
  830.       else {
  831.         if (add_method_impl(yy_class_name, yyval.text, yypvt[-4].position) == BERROR)
  832.           YYABORT;
  833.       }
  834.       *yy_class_name = '\0';
  835.     } break;
  836. case 27:
  837. # line 185 "gen.y"
  838. {
  839.       strcpy(yyval.text, yypvt[-0].text);
  840.       strcat(yyval.text, "()");
  841.       if (add_proc_impl(yyval.text, C_PROC, yypvt[-0].position) == BERROR)
  842.          YYABORT;
  843.       *yy_class_name = '\0';
  844.     } break;
  845. case 28:
  846. # line 192 "gen.y"
  847. {
  848.       fprintf(stderr, ">>>>>>  Arguments buffer overflow at line %d\n", yypvt[-0].position);
  849.       YYABORT;
  850.     } break;
  851. case 29:
  852. # line 202 "gen.y"
  853. { yyval.text[0] = '\0';         } break;
  854. case 30:
  855. # line 203 "gen.y"
  856. { strcpy(yyval.text, " const"); } break;
  857. case 31:
  858. # line 210 "gen.y"
  859. { yyval.text[0] = '\0';        } break;
  860. case 32:
  861. # line 211 "gen.y"
  862. { strcpy(yyval.text, yypvt[-0].text); } break;
  863. case 33:
  864. # line 212 "gen.y"
  865. {
  866.                                    strcpy(yyval.text, yypvt[-2].text);
  867.                                    strcat(yyval.text, ", ");
  868.                                    strcat(yyval.text, yypvt[-0].text);
  869.                                  } break;
  870. case 34:
  871. # line 223 "gen.y"
  872. { 
  873.       strcpy(yyval.text, yypvt[-1].text);
  874.       strcat(yyval.text, yypvt[-0].text);
  875.     } break;
  876. case 35:
  877. # line 227 "gen.y"
  878. { 
  879.       strcpy(yyval.text, "const ");
  880.       strcat(yyval.text, yypvt[-1].text);
  881.       strcat(yyval.text, yypvt[-0].text);
  882.     } break;
  883. case 36:
  884. # line 232 "gen.y"
  885. { 
  886.       strcpy(yyval.text, "const ");
  887.       strcat(yyval.text, yypvt[-2].text);
  888.       strcat(yyval.text, yypvt[-0].text);
  889.     } break;
  890. case 37:
  891. # line 243 "gen.y"
  892. { strcpy(yyval.text, "char"); } break;
  893. case 38:
  894. # line 244 "gen.y"
  895. { strcpy(yyval.text, "unsigned char"); } break;
  896. case 39:
  897. # line 245 "gen.y"
  898. { strcpy(yyval.text, "char"); } break;
  899. case 40:
  900. # line 246 "gen.y"
  901. { strcpy(yyval.text, "short"); } break;
  902. case 41:
  903. # line 247 "gen.y"
  904. { strcpy(yyval.text, "unsigned short"); } break;
  905. case 42:
  906. # line 248 "gen.y"
  907. { strcpy(yyval.text, "short"); } break;
  908. case 43:
  909. # line 249 "gen.y"
  910. { strcpy(yyval.text, "int"); } break;
  911. case 44:
  912. # line 250 "gen.y"
  913. { strcpy(yyval.text, "unsigned int"); } break;
  914. case 45:
  915. # line 251 "gen.y"
  916. { strcpy(yyval.text, "int"); } break;
  917. case 46:
  918. # line 252 "gen.y"
  919. { strcpy(yyval.text, "unsigned int"); } break;
  920. case 47:
  921. # line 253 "gen.y"
  922. { strcpy(yyval.text, "int"); } break;
  923. case 48:
  924. # line 254 "gen.y"
  925. { strcpy(yyval.text, "long"); } break;
  926. case 49:
  927. # line 255 "gen.y"
  928. { strcpy(yyval.text, "unsigned long"); } break;
  929. case 50:
  930. # line 256 "gen.y"
  931. { strcpy(yyval.text, "long"); } break;
  932. case 51:
  933. # line 257 "gen.y"
  934. { strcpy(yyval.text, yypvt[-0].text); } break;
  935. case 52:
  936. # line 258 "gen.y"
  937. { strcpy(yyval.text, yypvt[-0].text); } break;
  938. case 53:
  939. # line 259 "gen.y"
  940. { strcpy(yyval.text, yypvt[-0].text); } break;
  941. case 54:
  942. # line 260 "gen.y"
  943. { strcpy(yyval.text, yypvt[-0].text); } break;
  944. case 55:
  945. # line 267 "gen.y"
  946. { 
  947.       yyval.text[0]    = '\0';
  948.       yyval.precedence = MAX_PRECEDENCE;
  949.     } break;
  950. case 56:
  951. # line 271 "gen.y"
  952. { 
  953.       yyval.text[0]    = '\0';
  954.       yyval.precedence = MAX_PRECEDENCE;
  955.     } break;
  956. case 57:
  957. # line 275 "gen.y"
  958. {
  959.       strcpy(yyval.text, "*");
  960.       parentheses(S_PRECEDENCE, yypvt[-0], yyval)
  961.     } break;
  962. case 58:
  963. # line 279 "gen.y"
  964. {
  965.       strcpy(yyval.text, "*const ");
  966.       parentheses(S_PRECEDENCE, yypvt[-1], yyval)
  967.     } break;
  968. case 59:
  969. # line 283 "gen.y"
  970. {
  971.       strcpy(yyval.text, "&");
  972.       parentheses(P_PRECEDENCE, yypvt[-0], yyval)
  973.     } break;
  974. case 60:
  975. # line 287 "gen.y"
  976. {
  977.       strcpy(yyval.text, "&const ");
  978.       parentheses(P_PRECEDENCE, yypvt[-1], yyval)
  979.     } break;
  980. case 61:
  981. # line 291 "gen.y"
  982. {
  983.       yyval.text[0] = '\0';
  984.       parentheses(A_PRECEDENCE, yypvt[-1], yyval)
  985.       strcat(yyval.text, "[]");
  986.     } break;
  987. case 62:
  988. # line 296 "gen.y"
  989. {
  990.       strcpy(yyval.text, "(");
  991.       strcat(yyval.text, yypvt[-4].text);
  992.       strcat(yyval.text, ")");
  993.       strcat(yyval.text, " (");
  994.       strcat(yyval.text, yypvt[-1].text);
  995.       strcat(yyval.text, ")");
  996.       yyval.precedence = MAX_PRECEDENCE;
  997.     } break;
  998. case 63:
  999. # line 305 "gen.y"
  1000. {
  1001.       strcpy(yyval.text, yypvt[-1].text);
  1002.       yyval.precedence = yypvt[-1].precedence;
  1003.     } break;
  1004.     }
  1005.     goto yystack;        /* reset registers in driver code */
  1006. }
  1007.